﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <stdlib.h>
#include <assert.h>
using namespace std;
typedef int DataType;
//class A
//{
//private:
//	int _a;
//public:
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//};
//
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	(*p).Print();
//	return 0;
//}

//class Date
//{
//private:
//	int _year;
//	int _month;
//	int _day;
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//};
//
//int main()
//{
//	Date d1,d2;
//	d1.Init(2023, 7, 21);
//	d2.Init(2023, 7, 22);
//	d1.Print();
//	d2.Print();
//}

//class Date
//{
//private:
//	int _year;
//	int _month;
//	int _day;
//public:
//	////不带参数的构造函数
//	//Date()
//	//{
//	//	_year = 1;
//	//	_month = 1;
//	//	_day = 1;
//	//}
//	////带参数的构造函数
//	//Date(int year, int month, int day)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
//	//}
//	//全缺省构造函数
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//	}
//};
//
////int main()
////{
////	Date d1;
////	Date d2(2023, 7, 21);//想要调用带参数的构造函数必须将括号写在对象名后面而不是类名后面
////	d1.Print();
////	d2.Print();
////	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
////	 // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
////	 // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
////	Date d3();
////}
//
//int main()
//{
//	Date d(2023, 7);
//	d.Print();
//	return 0;
//}

//void f(int a = 1, int b = 2)
//{
//	cout << a << " " << b << endl;
//}
//void f()
//{
//	cout << "f()" << endl;
//}
//void f(int a)
//{
//	cout << "f(int a)\n";
//}
//
//int main()
//{
//	//f(1);
//	//f();
//	f(1, 2);
//	return 0;
//}


//class Stack
//{
//private:
//	int* _a;
//	int _top;
//	int _capacity;
//public:
//	//带缺省参数的构造函数
//	Stack(size_t capacity = 4)
//	{
//		_capacity = capacity;
//		_top = 0;
//		_a = (int*)malloc(sizeof(int) * _capacity);
//		assert(_a);
//	}
//	void Push(int val)
//	{
//		if (_capacity == _top)
//		{
//			_capacity *= 2;
//			int* tmp = (int*)realloc(_a, sizeof(int) * _capacity);
//			if (tmp)
//				_a = tmp;
//		}
//		_a[_top] = val;
//		_top++;
//	}
//	int& Top()
//	{
//		return _a[_top - 1];
//	}
//	void Pop()
//	{
//		assert(_top > 0);
//		_top--;
//	}
//	bool Empty()
//	{
//		assert(_top > 0);
//		return _top == 0;
//	}
//};
//
//int main()
//{
//	Stack st;
//	st.Push(1);
//	st.Push(2);
//	st.Push(3);
//	st.Push(4);
//	st.Push(5);
//	cout << st.Top() << endl;
//	st.Pop();
//	cout << st.Top() << endl;
//}

//class Stack
//{
//private:
//	int* _a;
//	int _top;
//	int _capacity;
//public:
//};
//int main()
//{
//	Stack st;
//	return 0;
//}

//class Date
//{
//public:
//	/*
//	// 如果用户显式定义了构造函数，编译器将不再生成
//	Date(int year, int month, int day)
//	{
//	_year = year;
//	_month = month;
//	_day = day;
//	}
//	*/
//
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
//		// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
//		// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
//		Date d1;
//		d1.Print();
//	return 0;
//}

//class Time
//{
//public:
//	Time()
//	{
//		cout << "Time()" << endl;
//		_hour = 0;
//		_minute = 0;
//		_second = 0;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//private:
//	// 基本类型(内置类型)
//	int _year;
//	int _month;
//	int _day;
//	// 自定义类型
//	Time _t;
//};
//int main()
//{
//	Date d;//调用Date类的系统默认构造函数
//	return 0;
//}

//class Time
//{
//public:
//	Time(int hour = 0, int minute = 0, int second = 0)
//	{
//		cout << "Time()" << endl;
//		_hour = hour;
//		_minute = minute;
//		_second = second;
//		cout << _hour << " " << _minute << " " <<  _second << endl;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//private:
//	// 基本类型(内置类型)
//	int _year;
//	int _month;
//	int _day;
//	// 自定义类型
//	Time _t;
//};
//int main()
//{
//	Date d;//调用Date类的系统默认构造函数
//	Time t;
//	t.Time::Time(1, 2, 3);
//	return 0;
//}

//class A
//{
//public:
//	void F()
//	{
//		Print();
//	}
//	void Print()
//	{
//		cout << "Print()" << endl;
//	}
//};
//int main()
//{
//	A a;
//	a.F();
//	return 0;
//}


////C++11给定缺省值
//class A
//{
//public:
//	void Print()
//	{
//		cout << _a << " " << _c << endl;
//	}
//private:
//	int _a = 1;
//	char _c = 'a';
//};
//
//int main()
//{
//	A a;//调用系统默认构造函数给_a初值1,_c初值'a'
//	a.Print();
//	return 0;
//}

////默认构造函数
//class A
//{
//	
//public:
//	//自定义无参构造函数
//	A()
//	{
//		cout << "A()\n";
//	}
//	//全缺省构造函数
//	A(int a = 1, int b = 2)
//	{
//		_a = a;
//		_b = b;
//		cout << "A(int a, int b)\n";
//	}
//private:
//	int _a;
//	int _b;
//};
//
//int main()
//{
//	A a;//无法编译通过，因为不知道调用哪一个默认构造函数
//	return 0;
//}


//typedef int DataType;
//class Stack
//{
//public:
//	Stack(size_t capacity = 3)
//	{
//		_array = (DataType*)malloc(sizeof(DataType) * capacity);
//		if (NULL == _array)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//	}
//	void Push(DataType data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//	// 其他方法...
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	int _capacity;
//	int _size;
//};
//void TestStack()
//{
//	Stack s;
//	s.Push(1);
//	s.Push(2);
//}
//
//class Time
//{
//public:
//	Time()
//	{
//		cout << "Time()" << endl;
//	}
//	~Time()
//	{
//		cout << "~Time()" << endl;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//public:
//	Date()
//	{
//		cout << "Date()" << endl;
//	}
//	~Date()
//	{
//		cout << "~Date()" << endl;
//	}
//private:
//	// 基本类型(内置类型)
//	int _year = 1970;
//	int _month = 1;
//	int _day = 1;
//	// 自定义类型
//	Time _t;
//};
//int main()
//{
//	Date d;
//	return 0;
//}

////拷贝构造函数
//class Stack
//{
//public:
//	Stack(size_t capacity = 3)
//	{
//		_array = (DataType*)malloc(sizeof(DataType) * capacity);
//		if (NULL == _array)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//	}
//	void Push(DataType data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	int _capacity;
//	int _size;
//};
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//void fun1(Date d1)
//{
//
//}
//void fun2(Stack st1)
//{
//
//}
//int main()
//{
//	Stack st;
//	Date d;
//	fun1(d);//传参时调用Date类型的默认拷贝构造函数
//	fun2(st);//传参时调用Stack类型的默认拷贝构造函数
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1900, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	// Date(const Date& d)   // 正确写法
//	Date( Date d)//错误写法---拷贝构造函数的参数不能是Date，否则会发生无穷递归
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1;
//	Date d2(d1);//传参时将d1拷贝给d:Date d(d1)，此时会调用拷贝构造函数,拷贝构造函数右会将d1拷贝给d:Date d(d1)引发无穷递归
//}


//class Time
//{
//public:
//	Time()
//	{
//		_hour = 1;
//		_minute = 1;
//		_second = 1;
//	}
//	Time(const Time& t)
//	{
//		_hour = t._hour;
//		_minute = t._minute;
//		_second = t._second;
//		cout << "Time::Time(const Time&)" << endl;
//	}
//private:
//	int _hour;
//	int _minute;
//	int _second;
//};
//class Date
//{
//private:
//	// 基本类型(内置类型)
//	int _year = 1970;
//	int _month = 1;
//	int _day = 1;
//	// 自定义类型
//	Time _t;
//};
//int main()
//{
//	Date d1;
//	Date d2(d1);
//	return 0;
//}

//class Stack
//{
//public:
//	Stack(size_t capacity = 4)
//	{
//		_array = (DataType*)malloc(sizeof(DataType) * capacity);
//		if (NULL == _array)
//		{
//			perror("malloc申请空间失败!!!");
//			return;
//		}
//		_capacity = capacity;
//		_size = 0;
//	}
//	//自定义拷贝构造函数实现深拷贝
//	Stack(const Stack& st)
//	{
//		_array = (DataType*)malloc(sizeof(DataType) * st._capacity);
//		if (nullptr == _array)
//		{
//			perror("malloc fail");
//			exit(-1);
//		}
//		memmove(_array, st._array, sizeof(DataType) * st._size);
//		_capacity = st._capacity;
//		_size = st._size;
//	}
//	void Push(DataType data)
//	{
//		// CheckCapacity();
//		_array[_size] = data;
//		_size++;
//	}
//	~Stack()
//	{
//		if (_array)
//		{
//			free(_array);
//			_array = NULL;
//			_capacity = 0;
//			_size = 0;
//		}
//	}
//private:
//	DataType* _array;
//	int _capacity;
//	int _size;
//};
//int main()
//{
//	Stack st1;
//	st1.Push(1);
//	st1.Push(2);
//	st1.Push(3);
//	Stack st2(st1);//调用拷贝构造函数完成深拷贝
//	return 0;
//}

class Date
{
public:
	Date(int year, int minute, int day)
	{
		cout << "Date(int,int,int):" << this << endl;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d):" << this << endl;
	}
	~Date()
	{
		cout << "~Date():" << this << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
Date Test(Date d)
{
	Date temp(d);
	return temp;
}
int main()
{
	Date d1(2022, 1, 13);//拷贝构造函数
	Test(d1);
	return 0;
}